home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Think Class Libraries / TP TCL->CW TCL v1.1.2.3 / UPI ƒ / Updated UPIs ƒ / DisAsmLookup.p < prev    next >
Text File  |  1996-02-07  |  23KB  |  480 lines
  1. {
  2.     File:        DisAsmLookup.p
  3.  
  4.     Copyright:    © 1983-1993 by Apple Computer, Inc.
  5.                 All rights reserved.
  6.  
  7.     Version:    System 7.1 for ETO #11
  8.     Created:    Tuesday, March 30, 1993 18:00
  9.  
  10. }
  11.  
  12. {$IFC UNDEFINED UsingIncludes}
  13. {$SETC UsingIncludes := 0}
  14. {$ENDC}
  15.  
  16. {$IFC NOT UsingIncludes}
  17.     UNIT DisAsmLookup;
  18.     INTERFACE
  19. {$ENDC}
  20.  
  21. {$IFC UNDEFINED UsingDisAsmLookup}
  22. {$SETC UsingDisAsmLookup := 1}
  23.  
  24. {$I+}
  25. {$SETC DisAsmLookupIncludes := UsingIncludes}
  26. {$SETC UsingIncludes := 1}
  27. {$IFC UNDEFINED UsingTypes}
  28. {$I $$Shell(PInterfaces)Types.p}
  29. {$ENDC}
  30. {$SETC UsingIncludes := DisAsmLookupIncludes}
  31.  
  32.  
  33. TYPE
  34.     LookupRegs    = (_A0_, _A1_, _A2_, _A3_, _A4_, _A5_, _A6_, _A7_,
  35.                                  _PC_, _ABS_, _TRAP_, _IMM_);
  36.  
  37. (*----------------------------------------------------------------------*)
  38.  
  39. PROCEDURE Disassembler(      DstAdjust:  LongInt;                  {addr correction}
  40.                                              VAR BytesUsed:  Integer;                  {bytes used up  }
  41.                                                      FirstByte:  UNIV Ptr;                 {starting byte  }
  42.                                              VAR Opcode:         UNIV Str255;          {mnemonic             }
  43.                                              VAR Operand:      UNIV Str255;        {operand        }
  44.                                              VAR Comment:      UNIV Str255;          {comment        }
  45.                                                      LookupProc: UNIV Ptr);              {search proc    }
  46.     (*
  47.      Disassembler is a Pascal routine to be called to disassemble a sequence
  48.      of bytes.  All MC68xxx, MC68881, and MC68851 instructions are supported.
  49.      The sequence of bytes to be disassembled are pointed to by FirstByte.
  50.      BytesUsed bytes starting at FirstByte are consumed by the disassembly,
  51.      and the Opcode, Operand, and Comment strings returned as NULL TERMINATED
  52.      Pascal strings (for easier manipulation with C). The caller is then free
  53.      to format or use the output strings any way appropriate to the
  54.      application.
  55.      
  56.      Depending on the opcode and effective address(s) (EA's) to be
  57.      disassembled, the Opcode, Operand, and Comment strings contain the
  58.      following information:
  59.      
  60.      Case                     Opcode    Operand    Comment
  61.      =======================================================================
  62.      Non PC-relative EA's     op.sz     EA's             ; 'c…' (for immediates)
  63.      PC-relative EA's         op.sz     EA's       ; address
  64.      Toolbox traps            DC.W      $AXXX      ; TB XXXX
  65.      OS traps                 DC.W      $AXXX      ; OS XXXX
  66.      Invalid bytes            DC.W      $XXXX      ; ????
  67.      =======================================================================
  68.      
  69.      For valid disassembly of processor instructions the appropriate MC68XXX
  70.      opcode mnemonic is generated for the Opcode string along with a size
  71.      attribute when required.  The source and destination EA's are generated
  72.      as the Operand along with a possible comment. Comments start with a ';'.
  73.      Traps use a DC.W assembler directive as the Opcode with the trap word
  74.      as the Operand and a comment indicating whether the trap is a toolbox or
  75.      OS trap and what the trap number is.  As described later the caller can
  76.      generate symbolic substitutions into EA's and provide names for traps.
  77.     
  78.      Invalid instructions cause the string 'DC.W' to be returned in the
  79.      Opcode string. Operand is '$XXXX' (the invalid word) with a comment of
  80.      '; ????'.  BytesUsed is 2.  This is similar to the trap call case except
  81.      for the comment.
  82.     
  83.      Note, the Operand EA's is syntatically similar to but NOT COMPATIBLE
  84.      with the MPW assembler!    This is because the Disassembler generates
  85.      byte hex constants as "$XX" and word hex constants as "$XXXX".  Negative
  86.      values (e.g., $FF or $FFFF) produced by the Disassembler are treated as
  87.      long word values by the MPW assembler.  Thus it is assumed that
  88.      Disassembler output will NOT be used as MPW assembler input.  If that is
  89.      the goal, then the caller must convert strings of the form $XX or $XXXX
  90.      in the Operand string to their decimal equivalent.  The routine
  91.      ModifyOperand is provided in this unit to aid with the conversion
  92.      process.
  93.     
  94.      Since a PC-relative comment is an address, the only address that the
  95.      Disassembler knows about is the address of the code pointed to by
  96.      FirstByte.  Generally, that may be a buffer that has no relation to
  97.      "reality", i.e., the actual code loaded into the buffer.  Therefore,
  98.      to allow the address comment to be mapped back to some actual address
  99.      the caller may specify an adjustment factor, specified by DstAdjust,
  100.      that is ADDED to the value that normally would be placed in the
  101.      comment.
  102.     
  103.      Operand effective address strings are generated as a function of the 
  104.      effective address mode and a special case is made for A-trap opcode
  105.      strings. In places where a possible symbolic reference could be
  106.      substituted for an address (or a portion of an address), the Disassembler
  107.      can call a user specified routine to do the substitution (using the
  108.      LookupProc parameter described later).  The following table summarizes
  109.      the generated effective addresses and where symbolic substitutions (S)
  110.      can be made:
  111.      
  112.      Mode    Generated Effective Address  Effective Address with Substitution
  113.      ========================================================================
  114.          0     Dn                           Dn
  115.          1     An                           An
  116.          2     (An)                         (An)
  117.          3     (An)+                        (An)+
  118.          4     -(An)                        -(An)
  119.          5     ∂(An)                        S(An) or just S (if An=A5, ∂≥0)
  120.         6n     ∂(An,Xn.Size*Scale)          S(An,Xn.Size*Scale)
  121.         6n     (BD,An,Xn.Size*Scale)        (S,An,Xn.Size*Scale)
  122.         6n     ([BD,An],Xm.Size*Scale,OD)   ([S,An],Xm.Size*Scale,OD)
  123.         6n     ([BD,An,Xn.Size*Scale],OD)   ([S,An,Xn.Size*Scale],OD)
  124.         70     ∂                            S
  125.         71     ∂                            S
  126.         72     *±∂                          S
  127.         73     *±∂(Xn.Size*Scale)           S(Xn.Size*Scale)
  128.         73     (*±∂,Xn.Size*Scale)          (S,Xn.Size*Scale)
  129.         73     ([*±∂],Xm.Size*Scale,OD)     ([S],Xm.Size*Scale,OD)
  130.         73     ([*±∂,Xn.Size*Scale],OD)     ([S,Xn.Size*Scale],OD)
  131.         74     #data                        S (#data made comment)
  132.      A-traps $AXXX                        S (as opcode, AXXX made comment)
  133.      ========================================================================
  134.  
  135.      For A-traps, the substitution can be performed to substitute for the DC.W
  136.      opcode string.  If the substitution is made then the Disassembler will
  137.      generate ,Sys and/or ,Immed flags as operands for Toolbox traps and
  138.      ,AutoPop for OS traps when the bits in the trap word indicates these
  139.      settings.
  140.      
  141.                      |         Generated          |            Substituted
  142.                      | Opcode  Operand  Comment   | Opcode  Operand        Comment
  143.      ========================================================================
  144.      Toolbox | DC.W    $AXXX    ; TB XXXX | S       [,Sys][,Immed] ; AXXX
  145.      OS      | DC.W    $AXXX    ; OS XXXX | S       [,AutoPop]     ; AXXX
  146.      ========================================================================
  147.  
  148.      All displacements (∂, BD, OD) are hexadecimal values shown as a byte
  149.      ($XX), word ($XXXX), or long ($XXXXXXXX) as appropriate.  The *Scale is
  150.      suppressed if 1. The Size is W or L.  Note that effective address
  151.      substitutions can only be made for "∂(An)", "BD,An", and "*±∂" cases.
  152.     
  153.      For all the effective address modes 5, 6n, 7n, and for A-traps, a
  154.      coroutine (a procedure) whose address is specified by the LookupProc
  155.      parameter is called by the Disassembler (if LookupProc is not NIL) to
  156.      do the substitution (or A-trap comment) with a string returned by the
  157.      proc.  It is assumed that the proc pointed to by LookupProc is a level 1
  158.      Pascal proc declared as follows:
  159.  
  160.      PROCEDURE Lookup(PC: UNIV Ptr;             {Addr of extension/trap word}
  161.                       BaseReg: LookupRegs;        {Base register/lookup mode  }
  162.                       Opnd: UNIV LongInt;         {Trap word, PC addr, disp.  }
  163.                       VAR S: Str255);            {Returned substitution      }
  164.  
  165.      or in C,
  166.      
  167.      pascal void LookUp(Ptr  PC,                /* Addr of extension/trap word */
  168.                         LookupRegs  BaseReg,    /* Base register/lookup mode   */
  169.                         long        Opnd,        /* Trap word, PC addr, disp.   */
  170.                         char        *S);        /* Returned substitution       */
  171.     
  172.      PC      = Pointer to instruction extension word or A-trap word in the
  173.                          buffer pointed to by the Disassembler's FirstByte parameter.
  174.  
  175.      BaseReg = This determines the meaning of the Opnd value and supplies
  176.                          the base register for the "∂(An)", "BD,An", and "*±∂" cases.
  177.                          BaseReg may contain any one of the following values:
  178.                         
  179.                          _A0_    =  0 ==> A0
  180.                          _A1_    =  1 ==> A1
  181.                          _A2_    =  2 ==> A2
  182.                          _A3_    =  3 ==> A3
  183.                          _A4_    =  4 ==> A4
  184.                          _A5_    =  5 ==> A5
  185.                          _A6_    =  6 ==> A6
  186.                          _A7_    =  7 ==> A7
  187.                          _PC_    =  8 ==> PC-relative (special case)
  188.                          _ABS_   =  9 ==> Abs addr    (special case)
  189.                          _TRAP_  = 10 ==> Trap word   (special case)
  190.                          _IMM_     = 11 ==> Immediate   (special case)
  191.                          
  192.                          For absolute addressing (modes 70 and 71), BaseReg contains
  193.                          _ABS_.  For A-traps, BaseReg would contain _TRAP_.  For
  194.                          immediate data (mode 74), BaseReg would contain _IMM_.
  195.      
  196.      Opnd    = The contents of this LongInt is determined by the BaseReg
  197.                          parameter just described.
  198.  
  199.                          For BaseReg = _IMM_ (immediate data):
  200.                                  Opnd contains the (extended) 32-bit immediate data specified
  201.                                  by the instruction.
  202.  
  203.                          For BaseReg = _TRAP_ (A-traps):
  204.                                  Opnd is the entire trap word. The high order 16 bits of
  205.                                  Opnd are zero.
  206.  
  207.                          For BaseReg = _ABS_  (absolute effective address):
  208.                                  Opnd contains the (extended) 32-bit address specifed by
  209.                                  the instruction's effective address.  Such addresses would
  210.                                  generally be used to reference low memory globals on a
  211.                                  Macintosh.
  212.  
  213.                          For BaseReg = _PC_  (PC-relative effective address):
  214.                                  Opnd contains the 32-bit address represented by "*±∂"
  215.                                  adjusted by the Disassembler's DstAdjust parameter.
  216.                                  
  217.                          For BaseReg = _An_  (effective address with a base register):
  218.                                  Opnd contains the (sign-extended) 32-bit (base)
  219.                                  displacement from the instruction's effective address.
  220.                                  
  221.                                  In the Macintosh environment, a BaseReg specifying A5
  222.                                  implies either global data references or Jump Table
  223.                                  references. Positive Opnd values with an A5 BaseReg thus
  224.                                  mean Jump Table references, while a negative offset would
  225.                                  mean a global data reference.  Base registers of A6 or A7
  226.                                  would usually mean local data.
  227.     
  228.      S       = Pascal string returned from Lookup containing the effective
  229.                          address substitution string or a trap name for A-traps.  S is
  230.                          set to null PRIOR to calling Lookup.  If it is still null on
  231.                          return, the string is not used.  If not null, then for A-traps,
  232.                          the returned string is used as the opcode string. In all other
  233.                          cases the string is substituted as shown in the above table.
  234.     
  235.      Depending on the application, the caller has three choices on how to
  236.      use the Disassembler and an associated Lookup proc:
  237.     
  238.      (1). The caller can call just the Disassembler and provide his own Lookup
  239.                 proc. In that case the calling conventions discussed above must be
  240.                 followed.
  241.     
  242.      (2). The caller can provide NIL for the LookupProc parameter, in which
  243.                 case, NO Lookup proc will be called.
  244.                 
  245.      (3). The caller can call first InitLookup (described below, a proc
  246.                 provided with this unit) and pass the address of this unit's
  247.                 standard Lookup proc when Disassembler is called.    In this case all
  248.                 the control logic to determine the kind of substitution to be done
  249.                 is provided for the caller and all that need to be provided by the
  250.                 user are routines to look up any or all of the following:
  251.                 
  252.                 • PC-relative references
  253.                 • Jump Table references
  254.                 • Absolute address references
  255.                 • Trap names
  256.                 • Immediate data names
  257.                 • References with offsets from base registers                                            *)
  258.                 
  259.  
  260. PROCEDURE InitLookup(PCRelProc, JTOffProc, TrapProc, AbsAddrProc, IdProc, ImmDataProc: UNIV Ptr);
  261.     {Prepare for use of this unit's Lookup proc.  When Disassembler is called
  262.      and the address of this unit's Lookup proc is specified, then for immediate
  263.      data, PC-relative, Jump Table references, A-traps, absolute addresses, and
  264.      offsets from a base register, the associated level 1 Pascal proc
  265.      specified here is called (if not NIL -- all six addresses are preset to
  266.      NIL).  The calls assume the following declarations for these procs (see
  267.      Lookup, below for further details):
  268.                                                      
  269.      PROCEDURE PCRelProc(Address: UNIV LongInt; 
  270.                                              VAR S:      UNIV Str255);
  271.  
  272.      PROCEDURE JTOffProc(A5JTOffset: UNIV Integer;
  273.                                              VAR S:         UNIV Str255);
  274.  
  275.      PROCEDURE TrapNameProc(TrapWord: UNIV Integer;
  276.                                                     VAR S:      UNIV Str255);
  277.                                                      
  278.      PROCEDURE AbsAddrProc(AbsAddr: UNIV LongInt;
  279.                                                  VAR S:      UNIV Str255);
  280.  
  281.      PROCEDURE IdProc(BaseReg: LookupRegs;
  282.                                         Offset:  UNIV LongInt;
  283.                                         VAR S:     UNIV Str255);
  284.                                                      
  285.      PROCEDURE ImmDataProc(ImmData: UNIV LongInt;
  286.                                                  VAR S:      UNIV Str255);
  287.  
  288.      Note: InitLookup contains initialized data which requires initializing
  289.                  at load time (this is of concern only to users with assembler
  290.                  main programs.}
  291.     
  292.  
  293.  PROCEDURE Lookup(        PC:      UNIV Ptr;     {Addr of extension/trap word}
  294.                                             BaseReg: LookupRegs;   {Base register/lookup mode  }
  295.                                             Opnd:    UNIV LongInt; {Trap word, PC addr, disp.  }
  296.                                     VAR S:       Str255);          {Returned substitution      }
  297.     {This is a standard Lookup proc available to the caller for calls to the
  298.      Disassembler.    If the caller elects to use this proc, then InitLookup
  299.      MUST be called prior to any calls to the Disassembler.  All the logic
  300.      to determine the type of lookup is done by this proc.  For PC-relative,
  301.      Jump Table references, A-traps, absolute addresses, and offsets from a
  302.      base register, the associated level 1 Pascal proc specified in the
  303.      InitLookup call (if not NIL) is called.
  304.     
  305.      This scheme simplifies the Lookup mechanism by allowing the caller
  306.      to deal with just the problems related to the application.}
  307.  
  308.  
  309. PROCEDURE LookupTrapName(TrapWord: UNIV Integer;
  310.                                                  VAR S:       UNIV Str255);
  311.     {This is a procedure provided to allow conversion of a trap instruction
  312.      (in TrapWord) to its corresponding trap name (in S).  It is provided
  313.      primarily for use with the Disassembler and its address may be passed to
  314.      InitLookup above for use by this unit's Lookup routine.  Alternatively,
  315.      there is nothing prohibiting the caller from using it directly for other
  316.      purposes or by some other Lookup proc.
  317.      
  318.      Note: The tables in this proc make the size of this proc about 9500
  319.                  bytes.  The trap names are fully spelled out in upper and lower
  320.                  case.}
  321.  
  322. PROCEDURE ModifyOperand(VAR Operand: UNIV Str255);
  323.     {Scan an operand string, i.e., the null terminated Pascal string returned
  324.      by the Disassembler (null MUST be present here) and modify negative hex
  325.      values to negated positive value.  For example, $FFFF(A5) would be
  326.      modified to -$0001(A5).  The operand to be processed is    passed as the
  327.      function's parameter which is edited "in place" and returned to the
  328.      caller.
  329.  
  330.      This routine is essentially a pattern matcher and attempts to only
  331.      modify 2, 4, and 8 digit hex strings in the operand that "might" be
  332.      offsets from a base register.  If the matching tests are passed, the
  333.      same number of original digits are output (because that indicates a
  334.      value's size -- byte, word, or long).
  335.  
  336.      For a hex string to be modified, the following tests must be passed:
  337.  
  338.      • There must have been exactly 2, 4, or 8 digits.
  339.  
  340.          Only hex strings $XX, $XXXX, and $XXXXXXXX are possible candidates
  341.          because that is the only way the Disassembler generates offsets.
  342.  
  343.      • Hex string must be delimited by a "(" or a ",".
  344.  
  345.          The "(" allows offsets for $XXXX(An,...) and $XX(An,Xn) addressing
  346.          modes.  The comma allows for the MC68020 addressing forms.
  347.  
  348.      • The "$X..." must NOT be preceded by a "±".
  349.  
  350.          This eliminates the possibility of modifying the offset of a
  351.          PC-relative addressing mode always generated in the form "*±$XXXX".
  352.      
  353.      • The "$X..." must NOT be preceded by a "#".
  354.      
  355.          This eliminates modifying immediate data.
  356.  
  357.      • Value must be negative.
  358.  
  359.          Negative values are the only values we modify.  A value $FFFF is
  360.          modified to -$0001.}
  361.  
  362. FUNCTION validMacsBugSymbol(symStart, limit: UNIV Ptr; symbol: StringPtr): StringPtr; C; EXTERNAL;
  363.     {Check that the bytes pointed to by symStart represents a valid MacsBug
  364.      symbol.  The symbol must be fully contained in the bytes starting at
  365.      symStart, up to, but not including, the byte pointed to by the limit
  366.      parameter.
  367.      
  368.      If a valid symbol is NOT found, then NIL is returned as the function's
  369.      result.  However, if a valid symbol is found, it is copied to symbol (if
  370.      it is not NIL) as a null terminated Pascal string, and return a pointer
  371.      to where we think the FOLLOWING module begins. In the "old style" cases
  372.      (see below) this will always be 8 or 16 bytes after the input symStart.
  373.      For new style Apple Pascal and C cases this will depend on the symbol
  374.      length, existence of a pad byte, and size of the constant (literal) area.
  375.      In all cases, trailing blanks are removed from the symbol.
  376.      
  377.      A valid MacsBug symbol consists of the characters '_', '%', spaces,
  378.      digits, and upper/lower case letters in a format determined by the first
  379.      two bytes of the symbol as follows:
  380.      
  381.         1st byte  | 2nd byte  |  Byte  |
  382.             Range   |  Range    | Length | Comments
  383.      =======================================================================
  384.         $20 - $7F | $20 - $7F |    8   | "Old style" MacsBug symbol format
  385.         $A0 - $7F | $20 - $7F |    8   | "Old style" MacsBug symbol format
  386.      -----------------------------------------------------------------------
  387.         $20 - $7F | $80 - $FF |   16   | "Old style" MacApp symbol ab==>b.a
  388.         $A0 - $7F | $80 - $FF |   16   | "Old style" MacApp symbol ab==>b.a
  389.      -----------------------------------------------------------------------
  390.         $80       | $01 - $FF |    n   | n = 2nd byte           (Apple symbol)
  391.         $81 - $9F | $00 - $FF |    m   | m = BAnd(1st byte,$7F) (Apple symbol)
  392.      =======================================================================
  393.      
  394.      The formats are determined by whether bit 7 is set in the first and
  395.      second bytes.  This bit will removed when we find it or'ed into the first
  396.      and/or second valid symbol characters.
  397.      
  398.      The first two formats in the above table are the basic "old style" (pre-
  399.      existing) MacsBug formats. The first byte may or may not have bit 7 set
  400.      the second byte is a valid symbol character.  The first byte (with bit 7
  401.      removed) and the next 7 bytes are assumed to comprise the symbol.
  402.      
  403.      The second pair of formats are also "old style" formats, but used for
  404.      MacApp symbols.  Bit 7 set in the second character indicates these
  405.      formats.  The symbol is assumed to be 16 bytes with the second 8 bytes
  406.      preceding the first 8 bytes in the generated symbol.  For example,
  407.      12345678abcdefgh represents the symbol abcdefgh.12345678.
  408.      
  409.      The last pair of formats are reserved by Apple and generated by the MPW
  410.      Pascal and C compilers.  In these cases the value of the first byte is
  411.      always between $80 and $9F, or with bit 7 removed, between $00 and $1F.
  412.      For $00, the second byte is the length of the symbol with that many bytes
  413.      following the second byte (thus a max length of 255). Values $01 to $1F
  414.      represent the length itself.  A pad byte may follow these variable length
  415.      cases if the symbol does not end on a word boundary.  Following the
  416.      symbol and the possible pad byte is a word containing the size of the
  417.      constants (literals) generated by the compiler.
  418.      
  419.      Note that if symStart actually does point to a valid MacsBug symbol,
  420.      then you may use showMacsBugSymbol to convert the MacsBug symbol bytes to
  421.      a string that could be used as a DC.B operand for disassembly purposes.
  422.      This string explicitly shows the MacsBug symbol encodings.}
  423.  
  424. FUNCTION endOfModule(address, limit: UNIV Ptr; symbol: StringPtr; VAR nextModule: UNIV Ptr): StringPtr; C; EXTERNAL;
  425.     {Check to see if the specified memory address, contains a RTS, JMP (A0) or
  426.      RTD #n instruction immediately followed by a valid MacsBug symbol.  These
  427.      sequences are the only ones which can determine an end of module when
  428.      MacsBug symbols are present.  During the check, the instruction and its
  429.      following MacsBug symbol must be fully contained in the bytes starting at
  430.      the specified address parameter, up to, but not including, the byte
  431.      pointed to by the limit parameter.
  432.     
  433.      If the end of module is NOT found, then NIL is returned as the
  434.      function's result.  However, if a end of module is found, the MacsBug
  435.      symbol is returned in symbol (if it is not NIL) as a null terminated
  436.      Pascal string (with trailing blanks removed), and the functions returns
  437.      the pointer to the start of the MacsBug symbol (i.e., address+2 for RTS
  438.      or JMP (A0) and address+4 for RTD #n).  This address may then be used as
  439.      in input parameter to showMacsBugSymbol to convert the MacsBug symbol to
  440.      a Disassembler operand string.
  441.      
  442.      Also returned in nextModule is where we think the FOLLOWING module
  443.      begins. In the "old style" cases (see validMacsBugSymbol) this will
  444.      always be 8 or 16 bytes after the input address.  For new style the
  445.      Apple Pascal and C cases this will depend on the symbol length, existence
  446.      of a pad byte, and size of the constant (literal) area.  See 
  447.      validMacsBugSymbol for a description of valid MacsBug symbol formats.}
  448.     
  449. FUNCTION showMacsBugSymbol(symStart, limit: UNIV Ptr; operand: StringPtr; VAR bytesUsed: Integer): StringPtr; C; EXTERNAL;
  450.     {Format a MacsBug symbol as a operand of a DC.B directive.  The first one
  451.      or two bytes of the symbol are generated as $80+'c' if they have there
  452.      high high bits set.  All other characters are shown as characters in a
  453.      string constant.  The pad byte, if present, is one is also shown as $00.
  454.      
  455.      When called, showMacsBugSymbol assumes that symStart is pointing at a
  456.      valid MacsBug symbol as validated by the validMacsBugSymbol or
  457.      endOfModule routines. As with validMacsBugSymbol, the symbol must be
  458.      fully contained in the bytes starting at symStart up to, but not
  459.      including, the byte pointed to by the limit parameter.
  460.      
  461.      The string is returned in the 'operand' parameter as a null terminated
  462.      Pascal string.  The function also returns a pointer to this string as its
  463.      return value (NIL is returned only if the byte pointed to by the limit
  464.      parameter is reached prior to processing the entire symbol -- which
  465.      should not happen if properly validated).  The number of bytes used for
  466.      the symbol is returned in bytesUsed.  Due to the way MacsBug symbols are
  467.      encoded, bytesUsed may not necessarily be the same as the length of the
  468.      operand string.
  469.      
  470.      A valid MacsBug symbol consists of the characters '_', '%', spaces,
  471.      digits, and upper/lower case letters in a format determined by the first
  472.      two bytes of the symbol as described in the validMacsBugSymbol routine.}
  473.  
  474. {$ENDC}    { UsingDisAsmLookup }
  475.  
  476. {$IFC NOT UsingIncludes}
  477.     END.
  478. {$ENDC}
  479.  
  480.